ReaderScanner.java

package com.fasterxml.aalto.in;

import java.io.*;

import javax.xml.stream.XMLStreamException;

import org.codehaus.stax2.XMLStreamLocation2;

import com.fasterxml.aalto.impl.ErrorConsts;

import com.fasterxml.aalto.impl.IoStreamException;

import com.fasterxml.aalto.impl.LocationImpl;

import com.fasterxml.aalto.util.DataUtil;

import com.fasterxml.aalto.util.TextBuilder;

import com.fasterxml.aalto.util.XmlCharTypes;

import com.fasterxml.aalto.util.XmlChars;

import com.fasterxml.aalto.util.XmlConsts;

/**

 * This is the concrete scanner implementation used when input comes

 * as a {@link java.io.Reader}. In general using this scanner is quite

 * a bit less optimal than that of {@link java.io.InputStream} based

 * scanner. Nonetheless, it is included for completeness, since Stax

 * interface allows passing Readers as input sources.

 */

public final class ReaderScanner

    extends XmlScanner

{

    /**

     * Although java chars are basically UTF-16 in memory, the closest

     * match for char types is Latin1.

     */

    /*

    /**********************************************************************

    /* Configuration

    /**********************************************************************

     */

    /**

     * Underlying InputStream to use for reading content.

     */

    protected Reader _in;

    /*

    /**********************************************************************

    /* Input buffering

    /**********************************************************************

     */

    protected char[] _inputBuffer;

    protected int _inputPtr;

    protected int _inputEnd;

    /**

     * Storage location for a single character that can not be pushed

     * back (for example, multi-byte char)

     */

    /*

    /**********************************************************************

    /* Symbol handling

    /**********************************************************************

    */

    /**

     * For now, symbol table contains prefixed names. In future it is

     * possible that they may be split into prefixes and local names?

     */

    protected final CharBasedPNameTable _symbols;

    /*

    /**********************************************************************

    /* Life-cycle

    /**********************************************************************

     */

    public ReaderScanner(ReaderConfig cfg, Reader r,

                         char[] buffer, int ptr, int last)

    {

    public ReaderScanner(ReaderConfig cfg, Reader r)

    {

    @Override

    protected void _releaseBuffers()

    {

        }

        /* Note: if we have block input (_in == null), the buffer we

         * use is not owned by scanner, can't recycle

         * Also note that this method will always get called before

         * _closeSource(); so that _in won't be cleared before we

         * have a chance to see it.

         */

            }

        }

    @Override

    protected void _closeSource() throws IOException

    {

        }

    /*

    /**********************************************************************

    /* Public scanner interface (1st level parsing)

    /**********************************************************************

     */

    @Override

    protected final void finishToken() throws XMLStreamException

    {

        case PROCESSING_INSTRUCTION:

        case CHARACTERS:

        case COMMENT:

        case SPACE:

        case DTD:

        case CDATA:

        default:

        }

    // // // First, main iteration methods

    @Override

    public final int nextFromProlog(boolean isProlog) throws XMLStreamException

    {

        }

        // First: keep track of where event started

        // Ok: we should get a WS or '<'. So, let's skip through WS

        while (true) {

            // Any more data? Just need a single byte

                }

            }

            // Really should get white space or '<'...

            }

                        }

                    }

                    }

                }

            }

        // Ok, got LT:

        }

        }

        }

        /* End tag not allowed if no open tree; and only one root

         * element (one root-level start tag)

         */

        }

    }

    @Override

    public final int nextFromTree() throws XMLStreamException

    {

                // !!! We don't yet parse DTD, don't know real contents

            }

        } else { // note: START_ELEMENT/END_ELEMENT never incomplete

                    // Important: retain same start location as with START_ELEMENT, don't overwrite

                }

                // Any namespace declarations that need to be unbound?

                }

            } else {

                // It's possible CHARACTERS entity with an entity ref:

                }

            }

        }

        // and except for special cases, mark down actual start location of the event

        /* Any more data? Although it'd be an error not to get any,

         * let's leave error reporting up to caller

         */

            }

        }

        /* Can get pretty much any type; start/end element, comment/PI,

         * CDATA, text, entity reference...

         */

            }

            }

            }

        }

            /* Need to expand; should indicate either text, or an unexpanded

             * entity reference

             */

            }

            /* Nope, a char entity; need to indicate it came from an entity.

             * Since we may want to store the char as is, too, let's negate

             * entity-based char

             */

            /* Let's store it for future reference. May or may not be used --

             * so let's not advance input ptr quite yet.

             */

        }

        // text, possibly/probably ok

        } else {

        }

    }

    /**

     * Helper method used to isolate things that need to be (re)set in

     * cases where 

     */

    protected int _nextEntity() {

        // !!! Also, have to assume start location has been set or such

        // !!! TODO: handle start location?

    }

    /*

    /**********************************************************************

    /* 2nd level parsing

    /**********************************************************************

     */

    protected final int handlePrologDeclStart(boolean isProlog) throws XMLStreamException

    {

        }

            }

                } else {

                }

            }

                // incomplete flag is set by handleDtdStart

                    }

                }

            }

        }

        /* error... for error recovery purposes, let's just pretend

         * like it was unfinished CHARACTERS, though.

         */

    }

    private final int handleDtdStart()

        throws XMLStreamException

    {

        // And then some white space and root  name

        //boolean gotId;

        } else {

        }

        /* Ok; so, need to get either an internal subset, or the

         * end:

         */

        }

                " (expected '[' for the internal subset, or '>' to end DOCTYPE declaration)" :

                " (expected a 'PUBLIC' or 'SYSTEM' keyword, '[' for the internal subset, or '>' to end DOCTYPE declaration)";

        }

        /* Need not parse the int. subset yet, can leave as is, and then

         * either skip or parse later on

         */

    }

    protected final int handleCommentOrCdataStart()

        throws XMLStreamException

    {

        }

        // Let's first see if it's a comment (simpler)

            }

            }

            } else {

            }

        }

        // If not, should be CDATA:

                }

                }

            }

            } else {

            }

        }

    }

    protected final int handlePIStart()

        throws XMLStreamException

    {

        // Ok, first, need a name

        }

        // Ok, first, need a name

        { // but is it "xml" (case insensitive)?

            }

        }

        /* Let's then verify that we either get a space, or closing

         * '?>': this way we'll catch some problems right away, and also

         * simplify actual processing of contents.

         */

        }

            // Ok, let's skip the white space...

            while (true) {

                    }

                    }

                }

                }

                }

            }

            // Ok, got non-space, need to push back:

            } else {

            }

        } else {

            }

            }

            }

        }

    }

    /**

     * @return Code point for the entity that expands to a valid XML

     *    content character.

     */

    protected final int handleCharEntity()

        throws XMLStreamException

    {

        // Hex or decimal?

        }

            while (true) {

                }

                }

                } else {

                }

                }

            }

        } else { // numeric (decimal)

                    }

                } else {

                }

                }

            }

        }

        // Ok, and then need to check result is a valid XML content char:

            }

            }

            // XML 1.1 allows most other chars; 1.0 does not:

                }

            }